//! 辅助表字段定义
//!
//! 自动根据表定义生成对应的orm字段定义，用于后续查询等关联字段

use std::marker::PhantomData;

use crate::{
    err::OrmResult,
    model::{
        query::{
            expr::QueryExpr,
            method::QueryMethod,
        },
        tools::{parse_date, parse_datetime, parse_time},
        types::{OrmDate, OrmDateTime, OrmTime},
        Model,
    },
};

/// 表字段
#[derive(Debug, Clone, Copy)]
pub struct TableField<T> {
    /// 对应在meta中的field序号
    pub field_index: u8,
    /// 标识实际字段存储数据类型
    _phantom: PhantomData<T>,
}

impl<T> TableField<T> {
    /// 新建表字段
    ///
    /// # 参数说明
    ///
    /// * field_index 对应在meta中的field序号
    pub const fn new(field_index: u8) -> Self {
        Self {
            field_index,
            _phantom: PhantomData,
        }
    }

    /// 连接其他表
    pub fn inner_join<'a>(&self, q: QueryExpr<'a>) -> QueryExpr<'a> {
        QueryExpr::new_item_with_join(self.field_index, false, q)
    }

    /// 连接其他表
    pub fn left_join<'a>(&self, q: QueryExpr<'a>) -> QueryExpr<'a> {
        QueryExpr::new_item_with_join(self.field_index, true, q)
    }
}

impl TableField<&str> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn any<'a>(&self, v: &'a str, method: QueryMethod) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Exact)
    }
    /// 包含
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn contains<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Contains)
    }
    /// 不包含
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn icontains<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::IContains)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Lte)
    }
    /// 以什么开头
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn starts_with<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Startswith)
    }
    /// 以什么结尾
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ends_with<'a>(&self, v: &'a str) -> QueryExpr<'a> {
        self.any(v, QueryMethod::Endswith)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [&str]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<i64> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: i64, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: i64) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: i64) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: i64) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: i64) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: i64) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [i64]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<i32> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: i32, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: i32) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: i32) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: i32) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: i32) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: i32) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [i32]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<i16> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: i16, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: i16) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: i16) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: i16) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: i16) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: i16) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [i16]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<i8> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: i8, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: i8) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: i8) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: i8) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: i8) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: i8) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [i8]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<u64> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: u64, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: u64) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: u64) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: u64) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: u64) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: u64) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [u64]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<u32> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: u32, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: u32) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: u32) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: u32) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: u32) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: u32) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [u32]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<u16> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: u16, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: u16) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: u16) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: u16) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: u16) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: u16) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [u16]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<u8> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: u8, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: u8) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: u8) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: u8) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: u8) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: u8) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [u8]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<f32> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: f32, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: f32) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: f32) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: f32) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: f32) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: f32) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [f32]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<f64> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: f64, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: f64) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: f64) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: f64) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: f64) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: f64) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }
    /// 在数组中
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn ins<'a>(&self, v: &'a [f64]) -> QueryExpr<'a> {
        QueryExpr::new_item(self.field_index, v, QueryMethod::In)
    }
}

impl TableField<OrmDate> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: OrmDate, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: OrmDate) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: OrmDate) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: OrmDate) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: OrmDate) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: OrmDate) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }

    /// 任意方法，通过字符串比较
    ///
    /// # 参数说明
    ///
    /// * v 查询值 必须为YYYY-MM-DD格式,否则将失败
    /// * method 字段比较方法
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD格式
    fn opt_str(&self, v: &str, method: QueryMethod) -> OrmResult<QueryExpr> {
        Ok(self.opt(parse_date(v)?, method))
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值必须为YYYY-MM-DD格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD格式
    pub fn eq_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值必须为YYYY-MM-DD格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD格式
    pub fn gt_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// * v 查询值必须为YYYY-MM-DD格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD格式
    pub fn gte_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// * v 查询值必须为YYYY-MM-DD格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD格式
    pub fn lt_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// * v 查询值必须为YYYY-MM-DD格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD格式
    pub fn lte_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Lte)
    }
}

impl TableField<OrmTime> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: OrmTime, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: OrmTime) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: OrmTime) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: OrmTime) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: OrmTime) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: OrmTime) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }

    /// 任意方法，通过字符串比较
    ///
    /// # 参数说明
    ///
    /// * v 查询值 必须为HH:MM:SS格式,否则将失败
    /// * method 字段比较方法
    ///
    /// # 失败
    ///
    /// 字符串格式非HH:MM:SS格式
    fn opt_str<'a>(&self, v: &str, method: QueryMethod) -> OrmResult<QueryExpr> {
        Ok(self.opt(parse_time(v)?, method))
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非HH:MM:SS格式
    pub fn eq_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非HH:MM:SS格式
    pub fn gt_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非HH:MM:SS格式
    pub fn gte_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非HH:MM:SS格式
    pub fn lt_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非HH:MM:SS格式
    pub fn lte_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Lte)
    }
}

impl TableField<OrmDateTime> {
    /// 任意方法
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    /// * method 字段比较方法
    fn opt(&self, v: OrmDateTime, method: QueryMethod) -> QueryExpr {
        QueryExpr::new_item(self.field_index, v, method)
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn eq(&self, v: OrmDateTime) -> QueryExpr {
        self.opt(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gt(&self, v: OrmDateTime) -> QueryExpr {
        self.opt(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn gte(&self, v: OrmDateTime) -> QueryExpr {
        self.opt(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lt(&self, v: OrmDateTime) -> QueryExpr {
        self.opt(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值
    pub fn lte(&self, v: OrmDateTime) -> QueryExpr {
        self.opt(v, QueryMethod::Lte)
    }

    /// 任意方法，通过字符串比较
    ///
    /// # 参数说明
    ///
    /// * v 查询值 必须为YYYY-MM-DD HH:MM:SS格式,否则将失败
    /// * method 字段比较方法
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD HH:MM:SS格式
    fn opt_str(&self, v: &str, method: QueryMethod) -> OrmResult<QueryExpr> {
        Ok(self.opt(parse_datetime(v)?, method))
    }
    /// 等于
    ///
    /// # 参数说明
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD HH:MM:SS格式
    pub fn eq_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Exact)
    }
    /// 大于
    ///
    /// # 参数说明
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD HH:MM:SS格式
    pub fn gt_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Gt)
    }
    /// 大于或等于
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD HH:MM:SS格式
    pub fn gte_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Gte)
    }
    /// 小于
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD HH:MM:SS格式
    pub fn lt_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Lt)
    }
    /// 小于或等于
    ///
    /// * v 查询值必须为HH:MM:SS格式,否则将失败
    ///
    /// # 失败
    ///
    /// 字符串格式非YYYY-MM-DD HH:MM:SS格式
    pub fn lte_str(&self, v: &str) -> OrmResult<QueryExpr> {
        self.opt_str(v, QueryMethod::Lte)
    }
}
/// 表字段特征定义
///
/// 用于查询等时直接使用字段名称
pub trait TableTrait<T>: Model {
    /// 表字段
    const COLUMN: T;
}
